[코담] 웹개발·실전 프로젝트·AI까지, 파이썬·장고의 모든것을 담아낸 강의와 개발 노트

딕셔너리와 반복문 | ✅저자: 이유정(박사)

🔹 딕셔너리 선언하기

🔹딕셔너리란?

딕셔너리(dictionary)는 key(키)와 value(값)를 쌍(pair)으로 
저장하는 자료형입니다.
예를 들어 "이름": "영희"처럼 어떤 값을 이름표처럼 붙여서 저장하는 
방식이에요.

◽ 딕셔너리 기본 구조

딕셔너리명 = {     
	키1: 값1,     
	키2: 값2,     
	키3: 값3 
}

키는 중복될 수 없으며, 값을 이름처럼 구분할 때 사용합니다.
리스트는 순서(index)로 꺼내지만, 딕셔너리는 키(key)로 꺼냅니다.

</> 예시코드:

user = {
    "name": "지민",
    "age": 28,
    "hobbies": ["독서", "사진", "요가"],
    "education": {
        "highschool": {
            "name": "서울고등학교",
            "graduated": True
        },
        "university": {
            "name": "한국대학교",
            "major": "심리학",
            "graduated": False
        }
    },
    "friends": [
        {"name": "태형", "age": 27},
        {"name": "석진", "age": 29}
    ]
}

◽ 시각적으로 표현한 구조

user
├── name: "지민"
├── age: 28
├── hobbies: ["독서", "사진", "요가"]
├── education
│   ├── highschool
│   │   ├── name: "서울고등학교"
│   │   └── graduated: True
│   └── university
│       ├── name: "한국대학교"
│       ├── major: "심리학"
│       └── graduated: False
└── friends
    ├── {"name": "태형", "age": 27}
    └── {"name": "석진", "age": 29}

🔍 구조형태 해설: 계층 리스트 형태입니다.

1️⃣ 딕셔너리 안에 리스트 넣기

person = {
    "name": "영희",
    "hobbies": ["독서", "요리", "등산"]
}
print(person["hobbies"][1])  # 요리

🧾 보충설명: "hobbies"라는 키에 리스트를 값으로 넣었습니다. ["독서", "요리", "등산"] 중 두 번째 값인 "요리"에 접근할 수 있어요.

2️⃣ 리스트 안에 딕셔너리 넣기

people = [
    {"name": "영희", "age": 20},
    {"name": "철수", "age": 22}
]
print(people[1]["name"])  # 철수

🧾 보충설명: 리스트 안에 딕셔너리 2개가 들어 있어요. people[1]은 두 번째 사람이고, 그 사람의 "name"은 "철수"입니다.

🔹 딕셔너리의 요소에 접근하기

파이썬 딕셔너리에서는 숫자 인덱스 대신 키(key)를 사용해 값을 
꺼냅니다.

📖 문법, 구문(syntax): 딕셔너리 값 꺼내는 기본 문법

딕셔너리["키"]

</> 예시코드: 키로 값 꺼내기

user = {"name": "영희", "age": 20}
print(user["name"])  # 영희
print(user["age"])   # 20

🖨️ 출력 결과:

영희   
20

🔍 해설:

"name"과 "age"는 키(key)
해당 키를 [] 안에 넣어서 값을 가져올 수 있어요

</>예시코드2 : 딕셔너리에서 값 꺼내기 (key로 접근)

student = {
    "name": "영희",
    "scores": [85, 92, 78],
    "profile": {
        "age": 21,
        "city": "서울"
    }
}

# 각 값 꺼내기
print(student["name"])           # 영희
print(student["scores"][1])      # 두 번째 점수 92
print(student["profile"]["city"])  # 사는 도시 서울

🖨️ 출력 결과:

영희
92
서울

🔍 해설:

student["name"] → 딕셔너리에서 "name" 키에 해당하는 값 "영희" 출력
student["scores"][1] → "scores" 키는 리스트이므로, 리스트 인덱스 [1] 로 "92" 출력
student["profile"]["city"] → "profile"은 딕셔너리, 그 안에서 "city" 키를 꺼내 "서울" 출력

</>예시코드3 :

person = {     
    "name": "영희",
    "age": 21,
    "address": {
        "city": "서울",
        "district": "강남구"
    },
    "hobbies": ["독서", "요리", "등산"]
} 

# 출력
print(f"이름: {person['name']}")
print(f"도시: {person['address']['city']}")
print(f"첫 번째 취미: {person['hobbies'][0]}")
print(f"나이: {person['age']}")

# 존재하지 않는 키 접근 (예외 방지)
nickname = person.get("nickname", "별명 없음")
my_age = person.get("age")
print(f"별명: {nickname}")
print(f"나이: {my_age}")

🖨️ 출력 결과:

이름: 영희
도시: 서울        
첫 번째 취미: 독서
별명: 별명 없음   
나이: 21

🔍 해설:

"address"는 딕셔너리 내부에 또 다른 딕셔너리가 들어 있는 
중첩 딕셔너리입니다.

"hobbies"는 리스트를 값으로 가진 항목으로, 리스트 내부 값에 
인덱스로 접근할 수 있습니다.

person[address][city]는 중첩된 딕셔너리에서 "city"라는 키의 값을
가져오는 방식입니다.

person[hobbies][0]은 "hobbies" 리스트의 첫 번째 요소(0번 인덱스를
출력합니다.

person.get("nickname", "별명 없음")은 "nickname"이라는 키가 없을
경우 에러 대신 기본값("별명 없음")을 반환합니다.

📝 문제1] 다음과 같은 사용자 정보 딕셔너리가 있습니다.
이름과 나이를 이용해 아래와 같은 형식으로 출력하세요.

"홍길동님은 성인입니다."
"김초롱님은 미성년자입니다."

users = [
    {"name": "홍길동", "age": 22},
    {"name": "김초롱", "age": 17}
]

🖨️ 출력 결과:

홍길동님은 성인입니다.  
김초롱님은 미성년자입니다.

✅ 정답 코드:

users = [
    {"name": "홍길동", "age": 22},
    {"name": "김초롱", "age": 17}
]

for user in users:
    if user["age"] >= 20:
        print(f"{user['name']}님은 성인입니다.")
    else:
        print(f"{user['name']}님은 미성년자입니다.")

🔍 해설:

딕셔너리 리스트를 반복문으로 순회
조건 분기
f-string 포맷

📝 문제2] 다음과 같은 딕셔너리 2개가 있습니다.
두 딕셔너리를 합쳐서 user_profile이라는 하나의 딕셔너리로 만들고 출력하세요.

base_info = {"name": "민수", "age": 30}
extra_info = {"email": "minsu@example.com", "phone": "010-0000-0000"}

🖨️ 출력 결과:

{'name': '민수', 'age': 30, 'email': 'minsu@example.com', 'phone': '010-0000-0000'}

✅ 정답 코드:

base_info = {"name": "민수", "age": 30}
extra_info = {"email": "minsu@example.com", "phone": "010-0000-0000"}

user_profile = {**base_info, **extra_info}
print(user_profile)

🔍 해설:

전개 연산자 **를 이용한 딕셔너리 병합
실무에서는 API 응답 통합, 사용자 기본 + 추가 정보 결합 등에 사용

📝 문제3] 다음 딕셔너리에서 score가 존재하는 경우 "점수 있음",
존재하지 않으면 "점수 없음"을 출력하는 코드를 작성하세요.
[] 접근을 쓰면 오류가 납니다. 안전하게 처리하세요.

student = {"name": "지연", "age": 19}

🖨️ 출력 결과:

점수 없음

✅ 정답 코드:

student = {"name": "지연", "age": 19}

if "score" in student:
    print("점수 있음")
else:
    print("점수 없음")

🔍 해설:

딕셔너리에 키가 있는지 확인할 때는 "키" in 딕셔너리 사용

🧾 보충설명: 리스트는 인덱스로 꺼내고,
딕셔너리는 키(key)로 꺼낸다는 점만 확실히 구분하면 됩니다!

◽ 딕셔너리의 문자열 키와 관련된 실수

딕셔너리에서 문자열 키(key)를 사용할 때 자주 하는 실수가 있어요.  
바로 키 이름을 정확하게 쓰지 않아서 생기는 오류입니다.
딕셔너리에서 값을 꺼낼 때 키는 철자 하나라도 틀리면 오류가 납니다.
"Name"과 "name"은 완전히 다른 키입니다.

❌ </> 예시코드: 대소문자를 다르게 쓰면 오류 발생

user = {     
	"name": "영희" 
} 

print(user["Name"])  # ❌

🖨️ 오류 메시지:

KeyError: 'Name'

🔍 해설:

"name"과 "Name"은 완전히 다른 문자열
파이썬의 딕셔너리는 대소문자를 구분하기 때문에
철자가 조금이라도 다르면 키를 찾지 못함

❌ </> 예시코드: 오타가 섞이면 오류 발생

student = {     
	"score": 95 
} 

print(student["socre"])  # ❌ 오타!

🖨️ 오류 메시지:

KeyError: 'socre'

🔍 해설:

"socre"는 "score"의 오타
철자 하나 차이로도 딕셔너리는 다른 키로 인식
따라서 정확한 철자로 접근해야 함

</> 예시코드: 외부 데이터와 키 이름 불일치

상황 설명: 당신은 사용자 정보를 담은 딕셔너리를 가지고 있고, 외부 API 또는 입력폼에서 받은 키 값을 기준으로 값을 꺼내야 합니다.
그런데 외부 키는 "UserName"처럼 대문자가 섞여 있고,
내부 딕셔너리에는 "username"처럼 소문자로 저장되어 있습니다.

# 외부에서 들어온 키 (대소문자 섞여 있음)
requested_key = "UserName"

# 내부 시스템에서 사용하는 딕셔너리
user_info = {
    "username": "kim_92",
    "email": "kim@example.com"
}

# 값 출력
print("사용자 이름:", user_info[requested_key])

🖨️ 오류 메시지:

KeyError: 'UserName'

✅ 해결법 1: .get() + lower() 조합

requested_key = "UserName"
user_info = {
    "username": "kim_92",
    "email": "kim@example.com"
}

# 외부 키를 소문자로 정규화
key = requested_key.lower()

# 안전하게 값 꺼내기
print("사용자 이름:", user_info.get(key, "정보 없음"))

🖨️ 출력 결과:

사용자 이름: kim_92

일반 for문

user_info = {}  # 빈 딕셔너리 생성

for k, v in raw_data.items(): # UserName, lee_01
    lower_key = k.lower()  # 키를 소문자로 변환 v = username email
    user_info[lower_key] = v  # 새 딕셔너리에 저장
    # user_info[username] = v # lee_01
    # user_info[email] = v # lee@example.com

✅ 해결법 2: 키 정규화 (모든 키 소문자로 저장)

# 외부에서 받아온 데이터 (키가 대소문자 섞임)
raw_data = {
    "UserName": "lee_01",
    "Email": "lee@example.com"
}

# 모든 키를 소문자로 변환하여 저장(Dictionary Comprehension)
user_info = {k.lower(): v for k, v in raw_data.items()}

# 이제 내부적으로 모두 소문자 키만 사용
print(user_info["username"])  # lee_01
print(user_info.get("email", "정보 없음")) # lee@example.com

raw_data.items()이란?

딕셔너리의 items() 메서드는 (키, 값) 쌍을 튜플 형태로 하나씩 꺼냅니다.

for k, v in raw_data.items(): # UserName, lee_01
    print(k, v)

🖨️ 출력 결과:

UserName lee_01  
Email lee@example.com

여기서:

k는 각각의 키 → "UserName", "Email"
v는 각각의 값 → "lee_01", "lee@example.com"

딕셔너리 컴프리헨션 작동 과정

user_info = {k.lower(): v for k, v in raw_data.items()}

이 문장은 다음과 같이 작동합니다:

반복	k	v	k.lower()	결과에 추가될 항목
1회	"UserName"	"lee_01"	"username"	`"username": "lee_01"`
2회	"Email"	"lee@example.com"	"email"	`"email": "lee@example.com"`

결과적으로 user_info는 다음과 같이 만들어집니다:

{'username': 'lee_01', 'email': 'lee@example.com'}

출력 부분 설명:

print(user_info["username"])  # 'lee_01'
print(user_info.get("email", "정보 없음"))  # 'lee@example.com'

첫 줄: "username" 키는 존재하므로 "lee_01" 출력
두 번째 줄: "email"도 존재하므로 get()의 기본값은 무시되고 실제 값 출력

🖨️ 출력:

lee_01  
lee@example.com

🔹 딕셔너리에 값 추가하기/제거하기

딕셔너리는 값을 저장할 뿐만 아니라, 나중에 새로운 키-값 쌍을 
추가하거나 기존 값을 삭제할 수 있어요.  
파이썬에서는 간단한 대입= 과 del 키워드를 이용해 딕셔너리를 수정
할 수 있습니다.
딕셔너리는 실시간으로 값을 추가하거나 지울 수 있는 유연한 구조입니다.

◽ 값 추가 방법

딕셔너리["새로운_키"] = 값

</> 예시코드: 값 추가하기

person = {"name": "영희"} 
person["age"] = 21 
print(person)

🖨️ 출력 결과:

{'name': '영희', 'age': 21}

🔍 해설:

"age"라는 새 키에 21이라는 값을 대입
딕셔너리에 항목이 추가됨

🔷 중첩 딕셔너리에 값을 추가하는 방법들

◽ 중첩 딕셔너리 전체를 한 번에 추가

user = {}

# 중첩 딕셔너리 전체를 추가
user["address"] = {
    "city": "서울",
    "zip": "12345"
}
print(user)

이 방식은 "address"라는 키에 딕셔너리 전체를 한 번에 통째로 추가합니다.

🖨️ 출력 결과:

{'address': {'city': '서울', 'zip': '12345'}}

◽ 중첩 딕셔너리의 하위 키만 나중에 추가

user = {"address": {}}  # 먼저 빈 딕셔너리 생성

# 중첩된 딕셔너리에 값 추가
user["address"]["city"] = "서울"
user["address"]["zip"] = "12345"
print(user)

이 방식은 중첩된 딕셔너리 안에 하나씩 값을 넣는 점(dot) 방식의 단계적 접근입니다.

🖨️ 출력 결과:

{'address': {'city': '서울', 'zip': '12345'}}

◽ 중첩 구조를 여러 계층으로 추가

user = {}
user["info"] = {}
user["info"]["address"] = {}
user["info"]["address"]["city"] = "서울"
user["info"]["address"]["zip"] = "12345"
print(user)

🖨️ 출력 결과:

{'info': {'address': {'city': '서울', 'zip': '12345'}}}

◽ 조건부 키 존재 확인 후 중첩 추가

user = {}

if "address" not in user: # 만약 user 딕셔너리에 address키가 없다면
    user["address"] = {}

user["address"]["city"] = "서울"
print(user)

🖨️ 출력 결과:

{'address': {'city': '서울'}}

◽ setdefault() 활용한 짧은 방식

user = {}
user.setdefault("address", {})["city"] = "서울"
user["address"]["zip"] = "12345"
print(user)

🖨️ 출력 결과:

{'address': {'city': '서울', 'zip': '12345'}}

🔷 딕셔너리에서 값을 제거하는 방법들

◽ 값 제거 방법

del 딕셔너리["키"]

</> 예시코드: 값 제거하기

person = {'name': '영희', 'age': 21}

del person["name"] 
print(person)

🖨️ 출력 결과:

{'age': 21}

🔍 해설:

"name" 키가 삭제되면서 그 항목이 사라짐
del은 특정 키를 완전히 제거할 때 사용

◽ del 딕셔너리["키"] — 특정 키 삭제

</> 예시코드:

person = {'name': '영희', 'age': 21}

del person["name"]
print(person)

🖨️ 출력 결과:

{'age': 21}

🔍 해설:

특정 "name" 키를 완전히 제거함
키가 존재하지 않으면 오류(KeyError) 발생

◽ .pop("키") — 키를 제거하고 값 반환

</> 예시코드:

person = {'name': '영희', 'age': 21}

removed = person.pop("name")
print("삭제된 값:", removed)
print(person)

🖨️ 출력 결과:

삭제된 값: 영희
{'age': 21}

🔍 해설:

"name" 키를 제거하면서 값을 변수에 반환
존재하지 않는 키를 제거하면 오류 발생 (예외처리 필요)

◽ .pop("키", 기본값) — 존재하지 않아도 오류 없이 삭제

</> 예시코드:

person = {'age': 21}

removed = person.pop("name", "없음")
print("삭제된 값:", removed)
print(person)

🖨️ 출력 결과:

삭제된 값: 없음
{'age': 21}

🔍 해설:

"name" 키가 없어도 기본값을 반환하고 오류 없이 진행
안정적인 삭제 방식

◽ .popitem() — 마지막 키-값 쌍 삭제

</> 예시코드:

person = {'name': '영희', 'age': 21}

removed = person.popitem()
print("삭제된 항목:", removed)
print(person)

🖨️ 출력 결과:

삭제된 항목: ('age', 21)
{'name': '영희'}

🔍 해설:

딕셔너리에서 마지막에 추가된 항목을 삭제
반환값은 (키, 값) 형태의 튜플
비어 있으면 오류 발생

◽ .clear() — 전체 삭제

</> 예시코드:

person = {'name': '영희', 'age': 21}

person.clear()
print(person)

🖨️ 출력 결과:

{}

🔍 해설:

딕셔너리의 모든 항목을 한 번에 삭제
딕셔너리는 존재하지만 내용만 빈 상태가 됨

📝 문제1] 사용자의 주소 정보를 조건에 따라 딕셔너리에 추가하세요.

user = {"name": "민수"}
city = input("도시를 입력하세요: ")

✨ 조건:

만약 사용자가 아무 입력도 하지 않으면 "city" 키는 추가하지 마세요.
사용자가 입력했다면 "address"라는 키 아래 "city" 키로 값을 저장하세요.
최종 결과를 출력하세요.

user = {"name": "민수"}
city = input("도시를 입력하세요: ").strip()

🖨️ 출력 결과: 입력 서울

{'name': '민수', 'address': {'city': '서울'}}

(입력 없이 엔터)

{'name': '민수'}

✅ 정답 코드:

user = {"name": "민수"}
city = input("도시를 입력하세요: ").strip()

if city:
    user["address"] = {"city": city}

print(user)

🔍 해설:

입력이 비어 있지 않으면 address 키를 만들어 내부에 city를 넣습니다.
빈 입력은 조건문에서 거르므로 address는 추가되지 않습니다.

📝 문제2] 딕셔너리에서 "score" 키를 삭제해보세요.

student = {"name": "수진", "score": 90}

✅ 정답 코드:

del student["score"] 
print(student)

🖨️ 출력 결과:

{'name': '수진'}

📝 문제3] 아래의 딕셔너리에서 "email" 키와 해당 값을 제거해보세요.

user = {
    "name": "민수",
    "age": 30,
    "email": "minsu@example.com"
}

제거한 뒤, 전체 딕셔너리를 출력해보세요.

🖨️ 출력 결과

{'name': '민수', 'age': 30}

✅ 정답 코드:

user = {
    "name": "민수",
    "age": 30,
    "email": "minsu@example.com"
}

del user["email"]
print(user)

🔍 해설

del 딕셔너리["키"]를 사용하면 해당 키-값 쌍을 제거할 수 있습니다.
존재하지 않는 키를 제거하려고 하면 KeyError가 발생하므로 주의하세요.

📝 문제4] 중첩 딕셔너리 내부 값 제거하기 다음 중첩 딕셔너리에서 "zip" 키를 제거하고 결과를 출력하세요.

user = {
    "name": "영희",
    "address": {
        "city": "서울",
        "district": "강남구",
        "zip": "12345"
    }
}

🖨️ 출력 결과:

{
    'name': '영희',
    'address': {
        'city': '서울',
        'district': '강남구'
    }
}

✅ 정답 코드:

user = {
    "name": "영희",
    "address": {
        "city": "서울",
        "district": "강남구",
        "zip": "12345"
    }
}

del user["address"]["zip"]
print(user)

🔍 해설

중첩된 딕셔너리 안의 키를 삭제할 때는 딕셔너리["키1"]["키2"] 형식으로 접근해야 합니다.
zip은 address라는 딕셔너리 안에 있는 키이므로 user["address"]["zip"]으로 접근합니다

🔹 KeyError 예외란?

딕셔너리에서 존재하지 않는 키(key)를 꺼내거나 삭제하려고 하면 
발생하는 오류입니다.

</> 예시코드: 없는 키로 값을 꺼내려 할 때

person = {"name": "유정"} 
print(person["age"])  # ❌

🖨️ 출력 결과:

KeyError: 'age'

🔍 해설:

"age"라는 키는 존재하지 않음
[] 접근 방식은 무조건 있어야 하므로, 없으면 오류 발생

</> 예시코드: 존재하지 않는 키 삭제할 때

my_dict = {"name": "지민"}
del my_dict["age"]  # ❌ age 키는 없음

🖨️ 출력 결과:

KeyError: 'age'

🔍 해설:

age 키가 없기 때문에 del 실행 시 오류 발생

🔹 딕셔너리 내부에 키가 있는지 확인하기

파이썬 딕셔너리는 값을 찾을 때도 항상 키(key)를 기준으로 찾습니다.  
그래서 그 키가 딕셔너리에 있는지 먼저 확인하는 습관이 중요합니다.

💡 딕셔너리에 "이 키가 있나?"를 확인하려면 in 또는 get()을 사용하세요!

방법	설명	장점
`"키" in 딕셔너리`	키가 있으면 `True`, <br>없으면 `False`	`KeyError` 방지 가능
`딕셔너리.get("키")`	키가 없으면 `None` 반환	에러 없이 안전하게 처리 가능
`딕셔너리.get("키", "기본값")`	키가 없으면 기본값 반환	사용자 친화적 메시지 가능

◽ `in` 키워드

in 키워드는 해당 키가 딕셔너리에 존재하는지 여부를 True / False로 
알려줍니다.

📖 문법, 구문(syntax):

"키" in 딕셔너리       # 키가 존재하면 True
"키" not in 딕셔너리   # 키가 존재하지 않으면 True

</> 예시코드:

user = {"name": "영희", "age": 20}

print("name" in user)      # True (존재함)
print("gender" in user)    # False (존재하지 않음)

print("age" not in user)   # False (존재하니까)
print("city" not in user)  # True (없으니까)

🔸 in 키워드 "이 서랍(label)이 있나요?"를 물어보는 것처럼, 값을 꺼내기 전에 "age"라는 키가 있는지 먼저 확인합니다.

user = {"name": "영희", "age": 20}

if "age" in user:     
    print(f"나이는 {user['age']}살입니다!")
else:
    print("나이 정보가 없습니다.")

🖨️ 출력:

나이는 20살입니다!

존재하는 "age" 키에 안전하게 접근

◽ 존재하지 않는 키를 미리 검사해 KeyError 방지 "gender"라는 키가 없기 때문에, 미리 확인하지 않으면 KeyError가 발생할 수 있어요.

</> 예시코드:

my_dict = {"name": "지민"}

if "gender" in my_dict:
    print(f"성별: {my_dict['gender']}")
else:
    print("gender 키가 존재하지 않아요.")

🖨️ 출력:

gender 키가 존재하지 않아요.

키가 없을 경우를 고려해 안전하게 처리

◽ `get()` 함수

키가 있으면 해당 값을, 없으면 None 또는 기본값을 반환합니다.  
 KeyError를 방지하는 데 유용합니다.

📖 문법, 구문(syntax):

딕셔너리.get("키")            # 키가 없으면 None 반환
딕셔너리.get("키", "기본값")   # 키가 없으면 기본값 반환

</> 예시코드1: 키가 없을 때 안전하게 처리

user = {"name": "영희"}

print(user.get("age"))               # 키가 없으면 → None
print(user.get("age", "정보 없음"))  # 키가 없으면 → "정보 없음"

🖨️ 출력 결과:

None
정보 없음

</> 예시코드2: 키가 있을 때는 값 반환

user = {"name": "영희", "age": 22}

print(user.get("name"))              # "영희"
print(user.get("age", "없음"))       # 22 → 기본값 무시됨

🖨️ 출력 결과:

영희
22

🔍 해설:

존재하는 키 조회: 해당 값 반환
존재하지 않는 키 조회: None 또는 기본값

💡 요약정리: 존재하는 키 사용: 정상 작동 존재하지 않는 키 사용: KeyError 발생 .get() 함수 사용: 오류 없이 기본값 반환 "키" in 딕셔너리 사용: 키 존재 여부 먼저 확인 가능

📝 문제1] 아래 딕셔너리에 "job" 키가 없을 때, "직업 정보 없음"을 출력해보세요.

person = {"name": "윤아", "age": 28}

✅ 정답 코드:

print(person.get("job", "직업 정보 없음"))

🖨️ 출력 결과:

직업 정보 없음

📝 문제2] 아래 딕셔너리에서 "email" 키가 존재할 때만 이메일을 출력하고, 없으면 "이메일 정보 없음"을 출력하세요.

user = {
    "name": "지민",
    "age": 25
}

✅ 정답 코드:

if "email" in user:
    print("이메일:", user["email"])
else:
    print("이메일 정보 없음")

🖨️ 출력 결과:

이메일 정보 없음

🔍 해설:

"email" in user로 먼저 키 존재 여부를 검사하여 KeyError를 방지합니다.

📝 문제3] 다음 조건을 만족하도록 코드를 완성하세요.

딕셔너리 book = {"title": "AI 101"}

"author" 키가 없을 경우 추가하고 "미상" 값을 넣기
결과 딕셔너리를 출력하세요.

✅ 정답 코드:

book = {"title": "AI 101"}

if "author" not in book:
    book["author"] = "미상"

print(book)

🖨️ 출력 결과:

{'title': 'AI 101', 'author': '미상'}

🔍 해설:

키가 없을 때만 값을 추가하는 조건문 활용 예시입니다.

📝 문제4] 사용자 입력을 받아 "email" 키가 존재하지 않으면 자동으로 추가하고 "이메일 미입력"으로 설정되도록 하세요.

❗ 단, setdefault()를 활용할 것

✅ 정답 코드:

user = {"name": "혜진"}

# 자동 추가: 없으면 생성
user.setdefault("email", "이메일 미입력")

print(user)

🖨️ 출력 결과:

{'name': '혜진', 'email': '이메일 미입력'}

🔍 해설:

.setdefault("키", 기본값)은 키가 없을 경우에만 추가합니다.
이미 존재하는 키는 덮어쓰지 않습니다.

🔹 `for` 반복문: 딕셔너리와 함께 사용하기

파이썬의 딕셔너리는 리스트처럼 for 반복문에 사용할 수 있습니다.  
하지만 딕셔너리는 "키(key)와 값(value)" 쌍으로 구성되기 때문에  
반복문에서 키만, 값만, 또는 둘 다 꺼낼 수 있습니다.

◽ 반복 방식 요약표

반복 구문	꺼내는 것 .....	설명
`for key in dict:`	키	가장 기본적인 반복 방식
`for value in dict.values():`	값	값들만 반복
`for key, value in dict.items():`	키와 값	(키, 값) 쌍을 동시에 반복, 가장 많이 사용됨

</> 예시코드1: 키만 반복 (기본)

user = {"name": "영희", "age": 22}  

for key in user:     
	print(key)

🖨️ 출력 결과:

name   
age

🔍 해설:

딕셔너리를 직접 반복하면 기본적으로 키만 꺼냅니다
user.keys()와 같은 결과를 반환

</> 예시코드2: 값만 반복하기

user = {"name": "영희", "age": 22}  

for value in user.values():     
	print(value)

🖨️ 출력 결과:

영희   
22

🔍 해설:

.values()를 사용하면 값들만 순회
합계 계산, 조건 필터링 등에 유용

</> 예시코드3: 키와 값 함께 반복하기

user = {"name": "영희", "age": 22}  

for key, value in user.items():
    print(f"{key} : {value}")

🖨️ 출력 결과:

name : 영희   
age : 22

🔍 해설:

.items()는 (키, 값) 쌍을 튜플로 반환
두 변수를 동시에 받아서 처리 가능
JSON 형식 데이터 처리 시 특히 자주 사용됨

💡 `.keys()`, `.values()`, `.items()`의 반환형

메서드	반환형	예시 결과
`.keys()`	dict_keys 객체	`dict_keys(['name', 'age'])`
`.values()`	dict_values 객체	`dict_values(['영희', 22])`
`.items()`	dict_items (튜플 목록)	`dict_items([('name', '영희'), ('age', 22)])`
딕셔너리의 `.keys()`는 list가 아닙니다.

user = {"name": "영희", "age": 22}
print(user.keys())

🖨️ 출력 결과:

dict_keys(['name', 'age'])

🤔 이건 리스트가 아니라 딕셔너리 전용의 특수한 객체예요.
이런 걸 뷰 객체(view object)라고 부릅니다.
→ 보기에는 리스트처럼 생겼지만, 완전히 똑같이 쓸 수는 없어요.

❓ 그렇다면 어떻게 리스트처럼 쓸 수 있나요? list()로 감싸면 됩니다!

keys = list(user.keys())
print(keys)

🖨️ 출력 결과:

['name', 'age']

이제 진짜 리스트처럼 인덱스로 접근하거나, 정렬하거나, 슬라이싱도 할 수 있어요!

</> 예시코드

user = {"name": "영희", "age": 22}

# 1. 키만 꺼내기
print("keys():", user.keys())

# 2. 값만 꺼내기
print("values():", user.values())

# 3. (키, 값) 쌍 꺼내기
print("items():", user.items())

🖨️ 출력 결과:

keys(): dict_keys(['name', 'age'])
values(): dict_values(['영희', 22])
items(): dict_items([('name', '영희'), ('age', 22)])

위의 예시코드를 리스트로 변환하면:

print(list(user.keys()))    # ['name', 'age']
print(list(user.values()))  # ['영희', 22]
print(list(user.items()))   # [('name', '영희'), ('age', 22)]

💭직접 풀어보세요.

📝 문제1] 딕셔너리 {"A": 90, "B": 85}에서 모든 키를 한 줄씩 출력해보세요.

✅ 정답 코드:

grades = {"A": 90, "B": 85}  for key in grades:     print(key)

🖨️ 출력 결과:

A   B

📝 문제2] 딕셔너리의 모든 값을 출력해보세요.

✅ 정답 코드:

for v in grades.values():     print(v)

🖨️ 출력 결과:

90   85

📝 문제3] "이름: 점수" 형태로 출력해보세요.

✅ 정답 코드:

for k, v in grades.items():     print(k, ":", v)

🖨️ 출력 결과:

A : 90   B : 85

📝 문제4] 아래 딕셔너리에서 두 번째 취미를 출력하세요.

student = {
    "name": "지우",
    "age": 17,
    "hobbies": ["음악 감상", "농구", "게임"]
}

🖨️ 출력 결과:

농구

✅ 정답 코드:

print(student["hobbies"][1])

🔍 해설:

"hobbies"는 리스트이므로, 인덱스로 접근해야 함 ([1] → 두 번째 요소)
딕셔너리 → 리스트 구조이므로 ["hobbies"][1] 사용

📝 문제5] 다음은 도서 정보입니다. 두 번째 책의 "title"을 출력해보세요.

books = [
    {"title": "파이썬 기초", "pages": 250},
    {"title": "코딩 인터뷰", "pages": 300}
]

🖨️ 출력 결과:

코딩 인터뷰

✅ 정답 코드:

print(books[1]["title"])

🔍 해설:

리스트 안에 딕셔너리가 있으므로 [1]로 두 번째 책을 접근
그 안에서 "title" 키로 값 출력

📝 문제6] 다음 정보를 담고 있는 user 딕셔너리를 만들고, "email" 값을 출력해보세요.

이름: 나현
이메일: nahyun@example.com
전화번호: "010-1234-5678"

user = {
    "name": "나현",
    "email": "nahyun@example.com",
    "phone": "010-1234-5678"
}

🖨️ 출력 결과:

nahyun@example.com

✅ 정답 코드:

user = {
    "name": "나현",
    "email": "nahyun@example.com",
    "phone": "010-1234-5678"
}

print(user["email"])

🔍 해설:

딕셔너리는 {}로 선언하고, "키": 값 형태로 데이터를 넣습니다.
"email"이라는 키로 값을 꺼낼 때는 user["email"]처럼 대괄호와 문자열 키를 사용합니다.
이 문제는 딕셔너리 선언과 기본 읽기를 연습하는 문제입니다.

📝 문제7] 다음 코드에서 발생할 수 있는 오류의 원인을 찾고, .get()을 사용하여 오류가 나지 않게 수정해보세요.

user = {
    "username": "minji"
}

print(user["email"])

🖨️ 출력 결과:

이메일 정보 없음

✅ 정답 코드:

print(user.get("email", "이메일 정보 없음"))

🔍 해설:

"email"이라는 키가 없기 때문에 user["email"]은 KeyError를 발생시킴
.get()을 사용하면 키가 없어도 오류 없이 기본값 출력 가능

📝 문제8] 중첩 딕셔너리에서 "city" 정보가 없을 경우 "도시 정보 없음"이 출력되도록 코드를 완성하세요.

person = {
    "name": "수지",
    "contact": {
        "email": "suji@example.com"
        # "city" 키는 없음
    }
}

🖨️ 출력 결과:

도시 정보 없음

✅ 정답 코드:

print(person.get("contact", {}).get("city", "도시 정보 없음"))

🔍 해설:

"contact"는 딕셔너리지만 "city"는 그 안에 없음
.get("contact", {})로 딕셔너리 기본값을 먼저 설정하고, 이어서 .get("city", "도시 정보 없음")을 호출해 이중 방어함

📝 문제9] 다음 코드에서 "nickname" 키가 있을 때만 출력하고, 없으면 아무 작업도 하지 않도록 조건문을 추가하세요.

user = {
    "name": "지훈"
    # "nickname" 없음
}

✅ 정답 코드:

if user.get("nickname"):
    print("별명:", user["nickname"])

🖨️ 출력 결과:
(출력 없음)

🔍 해설:

.get("nickname")은 존재하지 않는 키이므로 None을 반환
if None → 거짓이기 때문에 print()는 실행되지 않음
불필요한 오류 없이 키 존재 여부에 따라 안전하게 처리 가능

📝 문제 10] 다음 코드의 출력 결과를 예상해보세요.

user = {
    "name": "지민",
    "age": 25,
    "email": "jimin@example.com"
}

print(user.get("name"))
print(user.get("city"))

보기 A.

지민   
city

지민   
None

name   
city

지민   
KeyError

✅ 정답: B

🖨️ 출력 결과:

지민   
None

🔍 해설:

"name" 키는 존재하므로 "지민" 반환
"city" 키는 없지만 .get()은 KeyError를 발생시키지 않고 None을 반환함

📝 문제 11] 빈칸을 채워 중첩 딕셔너리에서 안전하게 값을 꺼내보세요.

user = {
    "name": "지민",
    "profile": {
        "email": "jimin@example.com",
        "phone": "010-1234-5678"
    }
}

# 아래 코드에서 ___에 들어갈 가장 적절한 표현은?

✅ 정답:

print(user.get("profile", {}).get("address", "주소 정보 없음"))

🖨️ 출력 결과:

주소 정보 없음

🔍 해설:

.get("profile")는 딕셔너리, 그 안의 "address"는 존재하지 않음
.get("address", "주소 정보 없음") → 없으므로 기본값 반환
중첩 구조에서도 get(..., {})를 사용하면 에러 없이 안전하게 접근 가능

📝 문제 12] 조건문과 .get()을 함께 사용하는 코드의 출력 결과는?

user = {
    "name": "지민",
    "hobbies": ["노래", "춤", "여행"]
}

if user.get("hobbies"):
    print("첫 번째 취미:", user["hobbies"][0])
else:
    print("취미 정보 없음")

예상 출력 결과는?

첫 번째 취미: 노래

취미 정보 없음

KeyError

None

✅ 정답: A

🖨️ 출력 결과:

첫 번째 취미: 노래

🔍 해설:

"hobbies" 키가 존재하고, 리스트도 비어있지 않으므로 True 조건 통과
user["hobbies"][0] → "노래" 출력

📝 문제 13] 다음 딕셔너리에서 "name"과 "origin" 키의 값을 출력하면 무엇이 나올까요?

dictionary = {
    "name": "7D 건조 망고",
    "type": "당절임",
    "ingredient": ["망고", "설탕", "메타중아황산나트륨", "치자황색소"],
    "origin": "필리핀"
}

print("name:", dictionary["name"])
print("origin:", dictionary["origin"])

출력 결과는?

name: 7D 건조 망고  
origin: 필리핀

name: 필리핀  
origin: 7D 건조 망고

name: ingredient  
origin: type

KeyError 발생

✅ 정답: A

🖨️ 출력 결과:

name: 7D 건조 망고  
origin: 필리핀

🔍 해설:

"name" 키에는 "7D 건조 망고"라는 값이 저장되어 있고,
"origin" 키에는 "필리핀"이라는 값이 저장되어 있음
→ 딕셔너리는 키를 통해 정확하게 원하는 값을 꺼낼 수 있음

📝 문제 14] 아래 코드에서 dictionary는 처음에 어떤 값을 출력할까요?

dictionary = {}

dictionary["name"] = "새로운 이름"
dictionary["head"] = "새로운 정신"
dictionary["body"] = "새로운 몸"

print("요소 추가 이후:", dictionary)

출력 결과는? A. 요소 추가 이전: []
B. 요소 추가 이전: None
C. 요소 추가 : {}
D. 요소 추가 이전: 빈 값

✅ 정답: C

🖨️ 출력 결과:

요소 추가 이전: {}

🔍 해설:

dictionary = {}는 빈 딕셔너리를 생성하는 문법
아무 요소가 없으므로 출력하면 {} 형태로 나옴

📝 문제 15] 아래 코드를 실행한 후 딕셔너리에 저장된 키-값 쌍을 고르세요.

dictionary = {}

dictionary["name"] = "새로운 이름"
dictionary["head"] = "새로운 정신"
dictionary["body"] = "새로운 몸"

print("요소 추가 이후:", dictionary)

출력 결과는?

요소 추가 이후: {'name': '새로운 이름'}

요소 추가 이후: {'head': '새로운 정신'}

요소 추가 이후: {'name': '새로운 이름', 'head': '새로운 정신', 'body': '새로운 몸'}

요소 추가 이후: {'name': '새로운 이름', 'head': '새로운 정신'}

✅ 정답: C

🖨️ 출력 결과:

요소 추가 이후: {'name': '새로운 이름', 'head': '새로운 정신', 'body': '새로운 몸'}

🔍 해설:

딕셔너리에 "키"를 지정해서 값을 하나씩 추가함
순서에 관계없이, 최종적으로 세 개의 키-값 쌍이 저장됨
딕셔너리는 리스트처럼 append 하지 않고, 키를 이용해 직접 추가함

📝 문제 16] 아래 코드에서 del 키워드는 어떤 역할을 하나요?

dictionary = {
    "name": "7D 건조 망고",
    "type": "당절임"
}

del dictionary["name"]

❓ 보기 A. "name" 키에 새로운 값을 추가한다
B. "name" 키의 값을 변경한다
C. "name"이라는 키와 그 값을 딕셔너리에서 삭제한다
D. 딕셔너리를 모두 초기화한다

✅ 정답: C

🔍 해설:

del 딕셔너리["키"]는 딕셔너리에서 해당 키와 그에 연결된 값까지 완전히 삭제합니다.
이 코드는 "name" 항목을 제거합니다.

📝 문제 17] 다음 코드 실행 후 딕셔너리는 어떤 상태가 될까요?

dictionary = {
    "name": "7D 건조 망고",
    "type": "당절임"
}

del dictionary["name"]
del dictionary["type"]

print("요소 제거 이후:", dictionary)

출력 결과는?

요소 제거 이후: {'type': '당절임'}

요소 제거 이후: {}

요소 제거 이후: {'name': '7D 건조 망고'}

KeyError가 발생한다

✅ 정답: B

🖨️ 출력 결과:

요소 제거 이후: {}

🔍 해설:

"name"과 "type" 두 키를 모두 삭제했기 때문에
딕셔너리는 더 이상 요소가 없는 **빈 딕셔너리 {}**가 됩니다.

📝 문제 18] 없는 키를 삭제하려고 하면?

del dictionary["price"]

🖨️ ❌ 출력:

KeyError: 'price'

🔍 해설:

존재하지 않는 키를 del로 삭제하려 하면 KeyError 발생
삭제 전 "키" in 딕셔너리로 확인하거나 .pop() 사용을 고려할 수 있음

📝 문제 19] 아래 코드는 어떤 결과를 출력할까요?

dictionary = {
    "name": "7D 건조 망고",
    "type": "당절임",
    "ingredient": ["망고", "설탕", "메타중아황산나트륨", "치자황색소"],
    "origin": "필리핀"
}

for key in dictionary:
    print(key, ":", dictionary[key])

출력 결과에 가장 가까운 것은? A.

name
type
ingredient
origin

7D 건조 망고
당절임
[...]
필리핀

name : 7D 건조 망고
type : 당절임
ingredient : ['망고', '설탕', '메타중아황산나트륨', '치자황색소']
origin : 필리핀

오류 발생 (KeyError)

✅ 정답: C

🖨️ 실제 출력 결과:

name : 7D 건조 망고
type : 당절임
ingredient : ['망고', '설탕', '메타중아황산나트륨', '치자황색소']
origin : 필리핀

🔍 해설:

for key in dictionary: 는 키만 반복
dictionary[key]를 통해 각 키에 해당하는 값을 출력
→ 따라서 키와 값을 함께 출력할 수 있음

📝 문제 20] 다음 코드도 같은 출력을 낼 수 있습니다. 어떤 문법이 사용되었나요?

for key, value in dictionary.items():
    print(key, ":", value)

보기 A. 리스트 내포
B. 튜플 분해 (key, value)
C. 딕셔너리 슬라이싱
D. 오류 발생

✅ 정답: B

🔍 해설:

dictionary.items()는 (key, value) 쌍의 튜플 목록을 반환합니다.
반복문에서 for key, value in ...는 튜플의 두 값을 한 번에 분해하여 변수에 저장하는 문법입니다.

📝 문제 21] 아래 둘은 출력 결과가 동일할까요?

for key in dictionary:
    print(key, ":", dictionary[key])

for key, value in dictionary.items():
    print(key, ":", value)

✅ 정답: 예 (동일한 결과)

🖨️ 동일한 출력:

name : 7D 건조 망고
type : 당절임
ingredient : ['망고', '설탕', '메타중아황산나트륨', '치자황색소']
origin : 필리핀

📝 문제 22] 다음 코드를 실행하면 어떤 결과가 출력될까요?

dictionary = {
    "name": "7D 건조 망고",
    "type": "당절임",
    "ingredient": ["망고", "설탕", "메타중아황산나트륨", "치자황색소"],
    "origin": "필리핀"
}

value = dictionary.get("존재하지 않는 키")
print("값:", value)

if value == None:
    print("존재하지 않는 키에 접근했었습니다.")

보기:

KeyError 발생

값: 존재하지 않는 키에 접근했었습니다.

값: None 존재하지 않는 키에 접근했었습니다.

값: 존재하지 않는 키 존재하지 않는 키에 접근했었습니다.

✅ 정답: C

🖨️ 출력 결과:

값: None 존재하지 않는 키에 접근했었습니다.

📝 문제 23] 다음 코드는 사용자에게 키를 입력받아, 딕셔너리에서 해당 값을 출력합니다.
사용자가 "price"를 입력했을 때, 출력 결과는 무엇일까요?

dictionary = {
    "name": "7D 건조 망고",
    "type": "당절임",
    "ingredient": ["망고", "설탕", "메타중아황산나트륨", "치자황색소"],
    "origin": "필리핀"
}

key = input("> 접근하고자 하는 키: ")

if key in dictionary:
    print(dictionary[key])
else:
    print("존재하지 않는 키에 접근하고 있습니다.")

</> 입력:

> 접근하고자 하는 키: price

출력 결과는?

A. price
B. None
C. KeyError
D. 존재하지 않는 키에 접근하고 있습니다.

✅ 정답: D

🖨️ 실제 출력 결과:

존재하지 않는 키에 접근하고 있습니다.

💡 해설:

"price"는 딕셔너리에 존재하지 않는 키
조건문 if key in dictionary:가 False이므로 else문 실행
따라서 안내 메시지가 출력됨

📝 문제24] 다음 딕셔너리에서 모든 키가 존재하는지 확인하고, 없을 경우 누락된 키 목록을 출력하세요.

required_keys = ["name", "email", "age"]
user = {"name": "보라", "age": 20}

✅ 정답 코드:

required_keys = ["name", "email", "age"]
user = {"name": "보라", "age": 20}

missing = [key for key in required_keys if key not in user]

if missing:
    print("누락된 키:", missing)
else:
    print("모든 정보가 입력되어 있습니다.")```

🖨️ 출력 결과:
```python
누락된 키: ['email']

🔍 해설:

리스트 컴프리헨션으로 누락된 키 목록을 만들고 출력함.
실무에서도 데이터 검증 시 자주 쓰이는 패턴입니다.

← 이전: 리스트와 반복문

다음 →: 미니프로젝트 4

💡 AI 인사이트

댓글 커뮤니티

검색

딕셔너리와 반복문 | ✅저자: 이유정(박사)

🔹 딕셔너리 선언하기

🔹딕셔너리란?

🔹 딕셔너리의 요소에 접근하기

◽ 딕셔너리의 문자열 키와 관련된 실수

🔹 딕셔너리에 값 추가하기/제거하기

🔷 중첩 딕셔너리에 값을 추가하는 방법들

🔷 딕셔너리에서 값을 제거하는 방법들

🔹 KeyError 예외란?

🔹 딕셔너리 내부에 키가 있는지 확인하기

◽ `in` 키워드

◽ `get()` 함수

🔹 `for` 반복문: 딕셔너리와 함께 사용하기

◽ 반복 방식 요약표

💡 `.keys()`, `.values()`, `.items()`의 반환형

💭직접 풀어보세요.

Python 코드 실행기

📝 입력값 (자동 생성됨)

📤 실행 결과:

사이트 및 광고 문의

💡 AI 인사이트

댓글 커뮤니티

검색

딕셔너리와 반복문 | ✅저자: 이유정(박사)

🔹 딕셔너리 선언하기

🔹딕셔너리란?

🔹 딕셔너리의 요소에 접근하기

◽ 딕셔너리의 문자열 키와 관련된 실수

🔹 딕셔너리에 값 추가하기/제거하기

🔷 중첩 딕셔너리에 값을 추가하는 방법들

🔷 딕셔너리에서 값을 제거하는 방법들

🔹 KeyError 예외란?

🔹 딕셔너리 내부에 키가 있는지 확인하기

◽ in 키워드

◽ get() 함수

🔹 for 반복문: 딕셔너리와 함께 사용하기

◽ 반복 방식 요약표

💡 .keys(), .values(), .items()의 반환형

💭직접 풀어보세요.

Python 코드 실행기

📝 입력값 (자동 생성됨)

📤 실행 결과:

사이트 및 광고 문의

◽ `in` 키워드

◽ `get()` 함수

🔹 `for` 반복문: 딕셔너리와 함께 사용하기

💡 `.keys()`, `.values()`, `.items()`의 반환형